Personal Computer World 2009 February/PCWFEB09.iso/Software/Resources/Chat & Communication/Digsby build 37/digsby_setup.exe/lib/social/twitter/twitter.pyo

Python Compiled Bytecode | 2008-10-13 | 30KB | 974 lines

# Source Generated with Decompyle++
# File: in.pyo (Python 2.5)

from social.network import SocialNetwork
from util.threads.threadpool2 import threaded
from threading import Lock
from util.cacheable import cproperty
from util.observe.observabledict import ObservableDict
from common.actions import action
from urllib2 import HTTPError
from collections import defaultdict
import common.notifications as common
from common.Protocol import ProtocolStatus
from protocols.api import adapt
from util import dictdiff, dictsub, get_snurl
from common.notifications import fire
from protocols.adapters import AdaptationFailure
from social.twitter.interfaces import ITwitterFetcher, IDisplayableTweet
from social.twitter.functions import pack_statuses2, unpack_statuses2, pack_direct_messages2, unpack_direct_messages2, time_filter, direct_msg
from social.twitter.constants import TAB_RELOAD_INTERVAL, TO_FIRE, ALL_TWEETS, TWITTER_HTTP
import objects
from common import pref
import urllib2
import simplejson
import socket
import httplib
import os
import wx
import time
import traceback
from operator import attrgetter
NORMAL_TWITTER_RATE = 100
SPAM_MESSAGE = 'Using Digsby for IM, Email, and Twitter - http://www.digsby.com'
TWEETS_KINDS_FOR_TAB = {
    'timeline': ALL_TWEETS,
    'replies': [
        'friend_reply'],
    'directs': [
        'direct_recieved'],
    'archive': [
        'self_reply',
        'self_tweet',
        'direct_sent'],
    'favorites': [
        'self_reply',
        'self_tweet',
        'friend_reply',
        'friend_tweet'] }

try:
    from _speedups import adapt
except ImportError:
    import sys
    print >>sys.stderr, 'WARNING: using slow protocols'

from logging import getLogger
log = getLogger('twitter')

class TwitterkStatus(ProtocolStatus):
    CHECKING = 'Checking...'


class Twitter(SocialNetwork):
    Statuses = TwitterkStatus
    protocol = 'twitter'
    service = protocol
    HTTP = TWITTER_HTTP
    url_cache = { }
    updatefreq = 60
    header_tabs = [
        'timeline',
        'replies',
        'directs',
        'archive',
        'favorites']
    timer_mapping = {
        'friends_timeline': 'statuses/friends_timeline.json',
        'direct_messages': 'direct_messages.json',
        'replies': 'replies.json' }
    filters = { }

    def __init__(self, *a, **kwargs):
        self.auto_throttle = kwargs.get('auto_throttle', self.default('auto_throttle'))
        self.do_spam = kwargs.get('do_spam', False)
        self.do_follow_digsby = kwargs.get('do_follow_digsby', False)
        self.name = kwargs['name']
        self.update_lock = Lock()
        self.header_funcs = [ (k, (lambda v = (v,): self.switch_to_tab(v)), False) for k, v in [
            ('Timeline', 'timeline'),
            ('Replies', 'replies'),
            ('Directs', 'directs'),
            ('Archive', 'archive'),
            ('Favorites', 'favorites')] ]
        self._current_tab = self.header_tabs[0]
        self._dirty = ObservableDict()
        self.timers = { }
        self.update_times = { }
        self.favorites_check_time = 0
        self.sent_check_time = 0
        self.have_succeeded = False
        for name in self.timer_mapping:
            self.timers[name] = kwargs.get(name, self.default(name))

        self.fetchers = dict((lambda .0: for key, val in .0:
(key, ITwitterFetcher(val)))(self.timer_mapping.iteritems()))
        self.marked_favorites = set()
        self.clean_init = False
        for tabname in self.header_tabs:
            self._dirty[tabname] = True

        SocialNetwork.__init__(self, *a, **kwargs)


    def onCreate(self):
        if self.do_follow_digsby:
            threaded(self.follow)(name = 'digsby', popups = False)

        if self.do_spam:
            threaded(self.send_tweet)(SPAM_MESSAGE, popups = False)



    def follow(self, name, popups = True):
        url = 'friendships/create/%s.json' % name

        try:
            _json = self.api._FetchUrl(url, post_data = { })
        except Exception:
            e = None
            traceback.print_exc()

            try:
                data = e.read()
                e.close()
                error_text = simplejson.loads(data)['error']
                if not error_text:
                    raise

                log.error('JSON error from twitter: %r', error_text)
                if popups:
                    wx.CallAfter(wx.MessageBox, error_text, _('Twitter Error'))
            except Exception:
                log.error('Non-JSON error while trying to send tweet: %r', e)
                if popups:
                    wx.CallAfter(wx.MessageBox, _('Digsby encountered an error attempting to follow "%s".' % name), _('Twitter Error'))

            except:
                popups

            return None



    def dirty(self):
        return self._dirty[self._current_tab]

    dirty = property(dirty)

    def update_frequencies(self):
        return self.timers.copy()

    update_frequencies = property(update_frequencies)

    def update_info(self, **info):
        info.pop('do_spam', None)
        info.pop('do_follow_digsby', None)
        for name in self.timer_mapping:
            if name in info or name not in self.timers:
                self.timers[name] = info.pop(name, self.default(name))
                continue


        try:
            del self._api
        except AttributeError:
            pass

        SocialNetwork.update_info(self, **info)


    def get_options(self):
        opts = SocialNetwork.get_options(self)
        for k, v in self.timers.items():
            if v != self.default(k):
                opts[k] = v
                continue

        if self.auto_throttle != self.default('auto_throttle'):
            opts['auto_throttle'] = self.auto_throttle

        return opts

    tweets = cproperty(dict, box = pack_statuses2, unbox = unpack_statuses2, user = True)
    direct_msgs = cproperty(dict, box = pack_direct_messages2, unbox = unpack_direct_messages2, user = True)
    favorites_check_time = cproperty(0, user = True)
    sent_check_time = cproperty(0, user = True)
    last_update = cproperty(0, user = True)

    def switch_to_tab(self, tabname):
        last = self._current_tab
        if tabname != last:
            self.setnotify('_current_tab', tabname)
            self.tabloaded(tabname)



    def tabloaded2(self, tabname, force = False):
        self.tabloaded(tabname, force)
        return True


    def tabloaded(self, tabname, force = False):
        if force and tabname == 'timeline':
            self.update_times.pop('friends_timeline', None)
            self._update(forced = [
                'friends_timeline'])
        elif force and tabname == 'replies':
            self.update_times.pop('replies', None)
            self._update(forced = [
                'replies'])
        elif force and tabname == 'directs':
            self.update_times.pop('direct_messages', None)
            self._update(forced = [
                'direct_messages'])
        elif tabname == 'archive':
            if force or time.time() >= self.sent_check_time + TAB_RELOAD_INTERVAL:

                try:
                    log.info('getting sent direct messages')
                    fetcher = ITwitterFetcher('direct_messages/sent.json')
                    sent = fetcher.Fetch(self.api)
                    (new_tweets, updated_tweets) = self.new_data(sent)
                    self.throw_mud(new_tweets + updated_tweets)
                    self.update_tweets(new_tweets + updated_tweets)
                    self.sent_check_time = time.time()
                    log.info('%d new from sent', len(new_tweets))
                except (IOError, urllib2.HTTPError, socket.error, httplib.HTTPException):
                    traceback.print_exc()
                except:
                    None<EXCEPTION MATCH>(IOError, urllib2.HTTPError, socket.error, httplib.HTTPException)


            None<EXCEPTION MATCH>(IOError, urllib2.HTTPError, socket.error, httplib.HTTPException)
        elif tabname == 'favorites':
            if force or time.time() >= self.favorites_check_time + TAB_RELOAD_INTERVAL:

                try:
                    log.info('getting sent direct messages')
                    fetcher = ITwitterFetcher('favorites.json')
                    favs = fetcher.Fetch(self.api)
                    for status in favs:
                        self.marked_favorites.add(status.id)

                    (new_tweets, updated_tweets) = self.new_data(favs)
                    self.throw_mud(new_tweets + updated_tweets)
                    self.update_tweets(new_tweets + updated_tweets)
                    self.favorites_check_time = time.time()
                    log.info('%d new from favorites', len(new_tweets))
                except (IOError, urllib2.HTTPError, socket.error, httplib.HTTPException):
                    traceback.print_exc()
                except:
                    None<EXCEPTION MATCH>(IOError, urllib2.HTTPError, socket.error, httplib.HTTPException)


            None<EXCEPTION MATCH>(IOError, urllib2.HTTPError, socket.error, httplib.HTTPException)


    tabloaded = threaded(tabloaded)

    def api(self):

        try:
            return self._api
        except AttributeError:
            import twitterapi as twitterapi
            self._api = twitterapi.TwitterApi(self)
            self._api.source = 'digsby'
            return self._api


    api = property(api)

    def Connect(self):
        self.on_connect()


    def Disconnect(self):
        self.change_state(self.Statuses.OFFLINE)


    def observe_count(self, callback):
        self.add_gui_observer(callback, '_current_tab')
        self._dirty.add_gui_observer(callback)


    def observe_state(self, callback):
        self.add_gui_observer(callback, 'enabled')


    def unobserve_count(self, callback):
        self.remove_gui_observer(callback, '_current_tab')
        self._dirty.remove_gui_observer(callback)


    def unobserve_state(self, callback):
        self.remove_gui_observer(callback)


    def getFeed(self, kind):
        display = []
        if kind == 'self_feed':
            kinds = ('self_tweet', 'self_reply')
        else:
            kinds = TWEETS_KINDS_FOR_TAB[kind]
        for tweet in self.tweets.itervalues():
            if tweet.kind in kinds:
                display.append(tweet)
                continue

        for tweet in self.direct_msgs.itervalues():
            if tweet.kind in kinds:
                display.append(tweet)
                continue

        ret = time_filter(sorted(display, key = attrgetter('created_at_in_seconds'), reverse = True))
        for val in ret:
            val.twitter = self
            val.do_cache(cache = self.url_cache)

        return ret


    def self_feed(self):
        return self.getFeed('self_feed')[:1]

    self_feed = property(self_feed)

    def timeline(self):
        tl = self.getFeed('timeline')[:50]
        if self.self_feed == tl[:1]:
            tl = tl[1:]

        return tl

    timeline = property(timeline)

    def replies(self):
        return self.getFeed('replies')[:50]

    replies = property(replies)

    def directs(self):
        return self.getFeed('directs')[:50]

    directs = property(directs)

    def archive(self):
        ar = self.getFeed('archive')[:50]
        if self.self_feed == ar[:1]:
            ar = ar[1:]

        return ar

    archive = property(archive)

    def favorites(self):
        return _[1][:50]

    favorites = property(favorites)

    def isFavorite(self, status):
        return status.id in self.marked_favorites


    def statusShouldShow(self, tweet, kind):
        if kind == 'create_favorite':
            return not self.isFavorite(tweet)
        elif kind == 'destroy_favorite':
            return self.isFavorite(tweet)
        elif kind == 'delete':
            return tweet.user.screen_name.lower() == self.name.lower()
        elif kind == 'reply' or kind == 'direct':
            return tweet.user.screen_name.lower() != self.name.lower()
        else:
            return False


    def directMessageShouldShow(self, tweet, kind):
        if kind == 'direct':
            return tweet.direct
        elif kind == 'delete':
            return tweet.sender.screen_name.lower() != self.name.lower()



    def shouldShow(self, tweet, kind):
        if not tweet.direct:
            return self.statusShouldShow(tweet, kind)

        if tweet.direct:
            return self.directMessageShouldShow(tweet, kind)

        return False


    def cleanup_iter(self, iterable):
        out = []
        for tweet in iterable:

            try:
                tweet = adapt(tweet, IDisplayableTweet)
            except AdaptationFailure:
                log.error('there was an error adapting %r', tweet)
                continue

            tweet.twitter = self
            tweet.do_cache(cache = self.url_cache)
            out.append(tweet)

        return out


    def new_data(self, l):
        l = self.cleanup_iter(l)
        tweets = { }
        direct_msgs = { }
        for tweet in l:
            if tweet.direct:
                direct_msgs[tweet.id] = tweet
                continue
            tweets[tweet.id] = tweet

        tweets = dictdiff(self.tweets, tweets)
        new_tweets = dictsub(tweets, self.tweets)
        updated_tweets = dictsub(tweets, new_tweets)
        direct_msgs = dictdiff(self.direct_msgs, direct_msgs)
        new_direct_msgs = dictsub(direct_msgs, self.direct_msgs)
        updated_direct_msgs = dictsub(direct_msgs, new_direct_msgs)
        return (new_tweets.values() + new_direct_msgs.values(), updated_tweets.values() + updated_direct_msgs.values())


    def update_tweets(self, tweets):
        for tweet in tweets:
            if tweet.direct:
                self.direct_msgs[tweet.id] = tweet
                continue
            self.tweets[tweet.id] = tweet

        self.direct_msgs = self.direct_msgs
        self.tweets = self.tweets


    def expire_tweets(self):
        num_non_favs = defaultdict((lambda : 0))
        tweets2 = { }
        for k, v in sorted(self.tweets.iteritems(), key = (lambda obj: obj[1].created_at_in_seconds), reverse = True):
            if v.id in self.marked_favorites:
                tweets2[k] = v
                continue
            if num_non_favs[v.kind] < 55:
                tweets2[k] = v
                num_non_favs[v.kind] += 1
                continue

        self.tweets = tweets2
        direct_msgs2 = { }
        for k, v in sorted(self.direct_msgs.iteritems(), key = (lambda obj: obj[1].created_at_in_seconds), reverse = True):
            if v.id in self.marked_favorites:
                direct_msgs2[k] = v
                continue
            if num_non_favs[v.kind] < 55:
                direct_msgs2[k] = v
                num_non_favs[v.kind] += 1
                continue

        self.direct_msgs = direct_msgs2


    def do_alerts(self, new_tweets):
        seen_tweet_ids = set()
        seen_direct_ids = set()
        tweets = defaultdict(list)
        for tweet in new_tweets:
            if tweet.kind in TO_FIRE:
                ids = None if tweet.direct else seen_tweet_ids
                if tweet.id not in ids:
                    ids.add(tweet.id)
                    tweets[TO_FIRE[tweet.kind]].append(tweet)

            tweet.id not in ids

        for topic, tweetitems in tweets.iteritems():
            tweetitems = sorted(tweetitems, key = attrgetter('created_at_in_seconds'), reverse = True)
            fire(topic, tweets = tweetitems, onclick = self.on_click, popupid = (self.name, topic))



    def throw_mud(self, tweets = None, favorites = False, all = False, **_k):
        if all:
            for tabname in TWEETS_KINDS_FOR_TAB.iterkeys():
                self._dirty[tabname] = True

            return None

        if favorites:
            pass

        kinds_found = set()
        for tweet in tweets:
            kinds_found.add(tweet.kind)

        for tabname, kinds in TWEETS_KINDS_FOR_TAB.iteritems():
            if favorites:
                if tabname != 'directs':
                    self._dirty[tabname] = True
                    continue


            if set(kinds).intersection(kinds_found):
                self._dirty[tabname] = True
                continue



    def muddy_status(self, status):
        status = self.cleanup_iter([
            status])[0]
        if status.kind in ('self_tweet', 'self_reply'):
            self.throw_mud(all = True)
            return None

        self.throw_mud((status,))


    def update(self):
        self._update(forced = self.timers.keys())

    update = action((lambda self: if not pref('can_has_social_update', False):
pass))(update)

    def reset_tweets(self):
        self.tweets = { }
        self.direct_msgs = { }
        self.set_all_dirty()

    reset_tweets = action((lambda self: if not pref('can_has_social_update', False):
pass))(reset_tweets)

    def set_all_dirty(self):
        self.throw_mud(all = True)

    set_all_dirty = action((lambda self: if not pref('can_has_social_update', False):
pass))(set_all_dirty)

    def reset_tab_times(self):
        self.favorites_check_time = 0
        self.sent_check_time = 0

    reset_tab_times = action((lambda self: if not pref('can_has_social_update', False):
pass))(reset_tab_times)

    def update_now(self):
        self._update()


    def count(self):
        pass

    count = property(count)

    def ensure_init(self):
        if not self.clean_init:
            self.change_state(self.Statuses.CONNECTING)
            self.tweets = dict((lambda .0: for tweet in .0:
(tweet.id, tweet))(self.cleanup_iter(self.tweets.values())))
            self.direct_msgs = dict((lambda .0: for tweet in .0:
(tweet.id, tweet))(self.cleanup_iter(self.direct_msgs.values())))
            for tab in self.header_tabs:
                self._dirty[tab] = True

            self.clean_init = True
        elif self.state is self.Statuses.OFFLINE:
            self.change_state(self.Statuses.CONNECTING)
        else:
            self.change_state(self.Statuses.CHECKING)


    def _update(self, forced = None):
        if forced is None:
            forced = []

        hourly_limit = NORMAL_TWITTER_RATE
        if self.auto_throttle:

            try:
                hourly_limit = self._get_max_hourly()['hourly_limit']
            except Exception:
                pass
            except:
                None<EXCEPTION MATCH>Exception


        None<EXCEPTION MATCH>Exception
        if not max(float(hourly_limit), 0):
            pass
        throttle_by = float(NORMAL_TWITTER_RATE) / NORMAL_TWITTER_RATE
        now = time.time()
        self.ensure_init()
        import gui.native.helpers as gui
        if gui.native.helpers.GetUserIdleTime() > pref('twitter.idle_time', type = int, default = 600000):
            return self.change_state(self.Statuses.ONLINE)

        results = { }
        cont = False

        def do_routine(key, fetcher, results):
            last_time = self.update_times.get(key, None)
            if key in forced:
                log.info('%s update forced', key)
            elif self.timers[key] == 0:
                log.info('%s update skipped, was 0', key)
                return None
            elif last_time is None or now > (last_time - 1) + self.timers[key] * 60 * throttle_by:
                log.info('%s update triggered', key)
            else:
                log.info("%s update skipped, hasn't been long enough", key)
                return None

            try:
                result = fetcher.Fetch(self.api)
            except urllib2.HTTPError:
                e = None
                if int(e.code) == 400:
                    self.update_times[key] = now
                    return False
                elif int(e.code) == 401:
                    return self.Reasons.BAD_PASSWORD
                else:
                    return self.Reasons.CONN_LOST
            except (IOError, urllib2.HTTPError, socket.error, httplib.HTTPException):
                return self.Reasons.CONN_LOST
            except ValueError:
                return self.Reasons.CONN_LOST

            self.update_times[key] = now
            (new_tweets, updated_tweets) = self.new_data(result)
            results[fetcher.id] = (new_tweets, updated_tweets)
            log.info('%d new from %r', len(new_tweets), fetcher.id)
            return True

        did_succeed = False
        for key, fetcher in self.fetchers.iteritems():
            err_count = 0
            for _i in xrange(3):
                ret = do_routine(key, fetcher, results)
                log.info('ret was %r', ret)
                if ret is False:
                    err_count = -1
                    break
                elif ret is self.Reasons.CONN_LOST:
                    err_count += 1
                elif ret is self.Reasons.BAD_PASSWORD:
                    self.set_offline(self.Reasons.BAD_PASSWORD)
                    return None
                elif ret is True:
                    did_succeed = True
                    break
                elif ret is None:
                    break

                if err_count < 3:
                    time.sleep(2)
                    continue

            if err_count in (-1,):
                break
                continue
        else:
            cont = True
        new_tweets_utl = { }
        updated_tweets_utl = { }
        err_count = 0
        for _i in xrange(3):

            try:
                tl_fetch_id = self.timer_mapping['friends_timeline']
                if cont and tl_fetch_id in results and not any((lambda .0: for tweet in .0:
tweet.kind == 'self_tweet')(results[tl_fetch_id][0])) and len(results[tl_fetch_id][0]) >= 20:
                    log.info('getting user timeline')
                    fetcher = ITwitterFetcher('statuses/user_timeline.json')
                    usertl = fetcher.Fetch(self.api)
                    (new_tweets_utl, updated_tweets_utl) = self.new_data(usertl)
                    results[fetcher.id] = (new_tweets_utl, updated_tweets_utl)
                    log.info('%d new from user timeline', len(new_tweets_utl))
                    did_succeed = True
                else:
                    log.info("didn't need to get user timeline")
            except urllib2.HTTPError:
                e = None
                if int(e.code) == 400:
                    break
                elif int(e.code) == 401:
                    self.set_offline(self.Reasons.BAD_PASSWORD)
                    return None
                else:
                    err_count += 1
            except (IOError, socket.error, httplib.HTTPException):
                err_count += 1
            except ValueError:
                err_count += 1

            if err_count < 3:
                time.sleep(2)
                continue

        if not did_succeed and not (self.have_succeeded):
            self.set_offline(self.Reasons.CONN_FAIL)
            return None
        else:
            self.have_succeeded = True
        if not results:
            self.change_state(self.Statuses.ONLINE)
            self._dirty_error = True
            return None

        to_alert = sum((lambda .0: for v in .0:
v[0])(results.itervalues()), [])
        newest = defaultdict((lambda : 0))
        for tweet in self.tweets.values():
            newest[tweet.kind] = max(newest[tweet.kind], tweet.created_at_in_seconds)

        for tweet in self.direct_msgs.values():
            newest[tweet.kind] = max(newest[tweet.kind], tweet.created_at_in_seconds)

        to_alert = (filter,)((lambda tweet: newest[tweet.kind] < tweet.created_at_in_seconds), to_alert)
        self.update_tweets(sum((lambda .0: for v in .0:
for val in v:
val)(results.itervalues()), []))
        self.throw_mud(sum((lambda .0: for v in .0:
v[0])(results.itervalues()), []))
        self.update_times = self.update_times
        self.do_alerts(to_alert)
        self.expire_tweets()
        if self.state != self.Statuses.OFFLINE:
            self.change_state(self.Statuses.ONLINE)
            self._dirty_error = True


    _update = threaded(_update)

    def cache_dir(self):
        return os.path.join('twitter', self.name)

    cache_dir = property(cache_dir)

    def cache_path(self):
        return os.path.join(self.cache_dir, 'twitter.dat')

    cache_path = property(cache_path)

    def find_tweet(self, id):

        try:
            return self.tweets[id]
        except AttributeError:
            return self.direct_msgs[id]



    def del_tweet(self, tweet):
        if not (tweet.direct) and self.tweets.pop(tweet.id, None) is not None:
            self.tweets = self.tweets

        if tweet.direct and self.direct_msgs.pop(tweet.id, None) is not None:
            self.direct_msgs = self.direct_msgs



    def on_click(self, tweet):
        if not tweet.direct:
            wx.LaunchDefaultBrowser(self.HTTP + '%s/statuses/%d' % (tweet.user.screen_name, tweet.id))

        if tweet.direct:
            return self.new_tweet_for_obj(tweet)



    def new_tweet_for_obj(self, tweet):
        if not tweet.direct:
            return self.new_tweet('@' + tweet.user.screen_name + ' ')

        if tweet.direct:
            return self.new_tweet('d ' + tweet.sender.screen_name + ' ')



    def new_tweet(self, prefix = ''):
        TwitterStatusDialog = TwitterStatusDialog
        import social.twitter.twittergui
        TwitterStatusDialog.ShowSetStatus(None, self.name, ok = (threaded,)((lambda info: self.send_tweet(**info))), initial_text = prefix, tiny_url = get_snurl)

    new_tweet = action((lambda self: if not self.state == self.Statuses.ONLINE:
pass))(new_tweet)
    OnClickHomeURL = OpenHomeURL = new_tweet

    def send_tweet(self, message, popups = True, **k):
        if not message:
            return None

        if isinstance(message, unicode):
            message = message.encode('utf-8')

        dm = direct_msg.match(message)
        if dm is not None:
            post_message = self.api.PostDirectMessageData
            post_args = dm.groups()
        else:
            post_message = self.api.PostUpdateData
            post_args = (message,)

        try:
            sent_msg = post_message(*post_args)
        except Exception:
            e = None
            traceback.print_exc()

            try:
                data = e.read()
                e.close()
                error_text = simplejson.loads(data)['error']
                if not error_text:
                    raise

                log.error('JSON error from twitter: %r', error_text)
                if popups:
                    wx.CallAfter(wx.MessageBox, error_text, _('Twitter Error'))
            except Exception:
                traceback.print_exc()
                log.error('Non-JSON error while trying to send tweet: %r', e)
                if popups:
                    wx.CallAfter(wx.MessageBox, _('Digsby encountered an error sending the message.'), _('Twitter Error'))

            except:
                popups

            if popups:
                wx.CallAfter(self.new_tweet, message)

            return None

        (new_tweets, updated_tweets) = self.new_data([
            sent_msg])
        self.update_tweets(new_tweets + updated_tweets)
        self.throw_mud(all = True)


    def destroy_direct_message(self, id):
        self._destroy_direct_message(id)
        return True


    def _destroy_direct_message(self, id):
        dm = self.find_tweet(int(id))
        url = 'direct_messages/destroy/%s.json' % dm.id

        try:
            self.api._FetchUrl(url, { })
        except HTTPError:
            e = None
            if int(e.code) != 404:
                traceback.print_exc()
                wx.CallAfter(wx.MessageBox, 'Digsby encountered an error deleting the direct message.')
                return None

        except Exception:
            traceback.print_exc()
            wx.CallAfter(wx.MessageBox, 'Digsby encountered an error deleting the direct message.')
            return None

        self.del_tweet(dm)
        self.muddy_status(dm)

    _destroy_direct_message = threaded(_destroy_direct_message)

    def destroy_status(self, id):
        self._destroy_status(id)
        return True


    def _destroy_status(self, id):
        status = self.find_tweet(int(id))
        url = 'statuses/destroy/%s.json' % status.id

        try:
            self.api._FetchUrl(url, { })
        except HTTPError:
            e = None
            if int(e.code) != 404:
                traceback.print_exc()
                wx.CallAfter(wx.MessageBox, 'Digsby encountered an error deleting the status message.')
                return None

        except Exception:
            traceback.print_exc()
            wx.CallAfter(wx.MessageBox, 'Digsby encountered an error deleting the status message.')
            return None

        self.del_tweet(status)
        self.muddy_status(status)

    _destroy_status = threaded(_destroy_status)

    def create_favorite(self, id):
        self._create_favorite(id)
        return True


    def _create_favorite(self, id):
        status = self.find_tweet(int(id))
        url = 'favorites/create/%s.json' % status.id

        try:
            self.api._FetchUrl(url, { })
        except HTTPError:
            e = None
            if int(e.code) != 404:
                traceback.print_exc()
                wx.CallAfter(wx.MessageBox, 'Digsby encountered an error creating the favorite.')
                return None

        except Exception:
            traceback.print_exc()
            wx.CallAfter(wx.MessageBox, 'Digsby encountered an error creating the favorite.')
            return None

        self.marked_favorites.add(status.id)
        self.muddy_status(status)

    _create_favorite = threaded(_create_favorite)

    def destroy_favorite(self, id):
        self._destroy_favorite(id)
        return True


    def _destroy_favorite(self, id):
        status = self.find_tweet(int(id))
        url = 'favorites/destroy/%s.json' % status.id

        try:
            self.api._FetchUrl(url, { })
        except HTTPError:
            e = None
            if int(e.code) != 404:
                traceback.print_exc()
                wx.CallAfter(wx.MessageBox, 'Digsby encountered an error removing the favorite.')
                return None

        except Exception:
            traceback.print_exc()
            wx.CallAfter(wx.MessageBox, 'Digsby encountered an error removing the favorite.')
            return None

        self.marked_favorites.remove(status.id)
        self.muddy_status(status)

    _destroy_favorite = threaded(_destroy_favorite)

    def _get_max_hourly(self):
        return simplejson.loads(self.api._FetchUrl('account/rate_limit_status.json'))

    get_max_hourly = threaded(_get_max_hourly)